const databaseModels = require(path.join(process.cwd(), "/modules/database")).getDatabase();

/**
 * 创建对象数据
 * @param {[type]} modelName 模型名称
 * @param {[type]} obj 模型对象
 * @param {Function} cb 回调函数
 */
module.exports.create = (modelName, obj, cb) => {
    var model = databaseModels[modelName];
    model.create(obj, cb);
}

/**
 * 获取所有数据
 * @param {[type]} modelName 模型名
 * @param {[type]} conditions 查询条件
 * 查询条件统一规范
 * conditions
    {
        "columns" : {
            字段条件
            "字段名" : "条件值"
        },
        "offset" : "偏移",
        "omit" : ["字段"],
        "only" : ["需要字段"],
        "limit" : "",
        "order" :[ 
            "字段" , A | Z,
            ...
        ]
    }
 * @param {function} cb 回调函数
 */
module.exports.list = (modelName, conditions, cb) => {
    var model = databaseModels[modelName];
    if (!model) return cb("模型不存在", null);

    if (conditions) {
        if (conditions['columns']) {
            model = model.find('columns')
        } else {
            model = model.find()
        }

        if (conditions["offset"]) {
            model = model.offset(parseInt(conditions["offset"]));
        }

        if (conditions["limit"]) {
            model = model.limit(parseInt(conditions["limit"]));
        }

        if (conditions["only"]) {
            model = model.only(conditions["only"]);
        }

        if (conditions["omit"]) {
            model = model.omit(conditions["omit"]);
        }

        if (conditions["order"]) {
            model = model.order(conditions["order"]);
        }
    } else {
        model = model.find();
    }
    if (!model) {
        cb(null, model.find());
    } else {
        cb('查询失败', null);
    }
}

/**
 * 查询满足条件的数量
 * @param {[type]} modelName 模型名
 * @param {[type]} conditions 查询条件
 * @param {function} cb 回调函数
 */
module.exports.countByConditions = (modelName, conditions, cb) => {
    var model = databaseModels[modelName];
    if (!model) return cb("模型不存在", null);
    var resultCB = function (err, count) {
        if (err) {
            return cb("查询失败", null);
        }
        cb(null, count);
    }

    if (conditions) {
        if (conditions["columns"]) {
            model = model.count(conditions["columns"], resultCB);
        } else {
            model = model.count(resultCB);
        }

    } else {
        model = model.count(resultCB);
    }
}

/**
 * 获取一条数据
 * @param  {[type]}   modelName  模型名称
 * @param  {[数组]}   conditions  条件集合
 * @param  {Function} cb         回调函数
 */
module.exports.findOne = (modelName, conditions, cb) => {
    var model = databaseModels[modelName];
    if (!model) return cb("模型不存在", null);
    if (!conditions) return cb("条件为空", null);
    model.findOne(conditions, (err, obj) => {
        if (err) {
            return cb("查询失败", null);
        }
        return cb(null, obj);
    })
}

/**
 * 更新对象数据
 * 
 * @param  {[type]}   modelName 模型名称
 * @param  {[type]}   id        数据关键ID
 * @param  {[type]}   updateObj 更新对象数据
 * @param  {Function} cb        回调函数
 */
module.exports.findByIdAndUpdate = (modelName, id, updateObj, cb) => {
    var model = databaseModels[modelName];
    if (!model) return cb("模型不存在", null);
    model.findByIdAndUpdate(id, updateObj, cb)
}

/**
 * 通过主键ID获取对象
 * @param  {[type]}   modelName 模型名称
 * @param  {[type]}   id        主键ID
 * @param  {Function} cb        回调函数
 */
module.exports.findById = (modelName, id, cb) => {
    var model = databaseModels[modelName];
    if (!model) return cb("模型不存在", null);
    model.findById(id, (err, obj) => {
        if (err) {
            return cb("查询失败", null);
        }
        return cb(null, obj);
    })
}

/**
 * 通过主键ID删除对象
 * 
 * @param  {[type]}   modelName 模型名称
 * @param  {[type]}   id        主键ID
 * @param  {Function} cb        回调函数
 */
module.exports.findByIdAndRemove = (modelName, id, cb) => {
    var model = databaseModels[modelName];
    if (!model) return cb("模型不存在", null);
    model.findByIdAndRemove(id, cb);
}

/**
 * 通过模型名称获取数据库数量
 * 
 * @param  {[type]}   modelName 模型名称
 * @param  {Function} cb        回调函数
 */
module.exports.count = (modelName, cb) => {
    var model = databaseModels[modelName];
    model.count(cb);
}

/**
 * 通过条件判断数据是否存在
 * 
 * @param  {[type]}   modelName  模块名
 * @param  {[type]}   conditions 条件
 * @param  {Function} cb         回调函数
 */
module.exports.exists = (modelName, conditions, cb) => {
    var model = databaseModels[modelName];
    model.exists(conditions, (isExists) => {
        cb(null, isExists)
    })
}

module.exports.getModel = (modelName) => {
    return databaseModels[modelName];
}